/**
 * 对应管理员端预测模块
 */
package xiangmu.schoolpaper.service.impl.system;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.fasterxml.jackson.databind.JsonNode;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import xiangmu.schoolpaper.mapper.DictMajorMapper;
import xiangmu.schoolpaper.mapper.system.PredictionKeywordsMapper;
import xiangmu.schoolpaper.mapper.SplitPaperMetadataMapper;
import xiangmu.schoolpaper.pojo.DTO.KeywordsQuery;
import xiangmu.schoolpaper.pojo.entity.DictMajor;
import xiangmu.schoolpaper.pojo.entity.SplitPaperMetadata;
import xiangmu.schoolpaper.service.system.PredictionKeywordsService;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class PredictionKeywordsServiceImpl implements PredictionKeywordsService {

    @Autowired
    private PredictionKeywordsMapper sysPredictionKeywordsMapper;

    private List<String> keywordArray;

    @Autowired
    private DictMajorMapper dictMajorMapper;

    @Autowired
    private SplitPaperMetadataMapper  splitPaperMetadataMapper;


    public List<String> getAllMajors() {
        // 查询所有未删除的专业
        List<DictMajor> list = dictMajorMapper.selectList(
                new QueryWrapper<DictMajor>().eq("del_flag", 1)
        );

        // 只要专业名称
        return list.stream().map(DictMajor::getMajorName).collect(Collectors.toList());
    }

    public List<Integer> getAllCompletionYears() {
        List<SplitPaperMetadata> list = splitPaperMetadataMapper.selectList(null);

        // 取出 completionTime 转成年份
        return list.stream()
                .map(SplitPaperMetadata::getCompletionTime)
                .filter(Objects::nonNull)
                .map(LocalDateTime::getYear)
                .distinct() // 如果你只要唯一的年份，可以加这个
                .sorted()   // 排序
                .collect(Collectors.toList());
    }


    @Override
    public List<Map<String, Object>> getKeywordsTable(String major,String grade) {
//        取前15个关键词
        int topN = 15;

//        获取筛选条件下的所有关键词
        List<String> allKeywords = sysPredictionKeywordsMapper.getKeywordsTable(major,grade);

//        拆分统计
        Map<String, Long> keywordCount = new HashMap<>();
        allKeywords.stream()
                .filter(Objects::nonNull)
                .flatMap(keywords -> Arrays.stream(keywords.split("；")))
                .map(String::trim)
                .filter(word -> !word.isEmpty())
                .forEach(word -> keywordCount.put(word, keywordCount.getOrDefault(word, 0L) + 1));

//        排序并限制数量
        List<Map<String, Object>> resultList = keywordCount.entrySet().stream()
                .sorted(Map.Entry.<String, Long>comparingByValue().reversed())
                .limit(topN)
                .map(entry -> {
                    Map<String, Object> result = new HashMap<>();
                    result.put("keyWord", entry.getKey());
                    result.put("count", entry.getValue());
                    return result;
                })
                .toList();

        // 单独存关键词
        this.keywordArray = resultList.stream()
                .map(item -> (String) item.get("keyWord"))
                .collect(Collectors.toList());

        return resultList;
    }

    public static String buildPromptFromKeywords(List<String> topKeywords, String userInputRequirement) {
        String keywords = String.join("、", topKeywords);

        // 如果用户没有输入要求，就使用默认要求
        String instruction = (userInputRequirement == null || userInputRequirement.isBlank())
                ? "请分析当前这些关键词的研究热点、趋势和潜在发展方向。"
                : userInputRequirement;

        return """
        以下是近期论文中出现频率较高的关键词：

        %s

        请根据这些关键词，%s
        """.formatted(keywords, instruction);
    }



    private static final String API_URL = "https://api.moonshot.cn/v1/chat/completions";
    private static final String API_KEY = "sk-7gAs5FgAQTGnOxvicYdUJ72SNKBaBh1Q6LgOSvO8E6MBJr4v";
    @Override
    public String AiPredictByKeywords(String query){
        try {

            System.out.println(keywordArray);
            if (keywordArray == null || keywordArray.isEmpty()) {
                return "关键词为空，请先调用 getKeywordsTable()，请注意：本接口运行慢";
            }

            HttpPost post = new HttpPost(API_URL);
            post.setHeader("Authorization", "Bearer " + API_KEY);
            post.setHeader("Content-Type", "application/json");


            String safePrompt = buildPromptFromKeywords(keywordArray, query);
            String prompt = safePrompt.replace("\"", "\\\"").replace("\n", "\\n");


            String body = """
            {
              "model": "moonshot-v1-8k",
              "messages": [
                { "role": "system", "content": "你是一个科研助手，擅长热点预测与趋势分析。" },
                { "role": "user", "content": "%s" }
              ],
              "temperature": 0.7
            }
            """.formatted(prompt);
            HttpClient client = HttpClients.createDefault();

            post.setEntity(new StringEntity(body, "UTF-8"));

            HttpResponse response = client.execute(post);

            // 解析响应体
            String result = EntityUtils.toString(response.getEntity(), "UTF-8");

            // 安全解析 JSON，只返回 content
            ObjectMapper mapper = new ObjectMapper();
            JsonNode root = mapper.readTree(result);
            JsonNode choices = root.path("choices");

            if (choices.isArray() && !choices.isEmpty()) {
                JsonNode firstChoice = choices.get(0);
                JsonNode messageNode = firstChoice.path("message");
                JsonNode contentNode = messageNode.path("content");
                return contentNode.isMissingNode() ? "" : contentNode.asText();
            } else {
                // choices 为空或不合法，返回默认提示
                return "AI 未返回内容";
            }

        } catch (Exception e) {
            e.printStackTrace();
            return "请求失败：" + e.getMessage();
        }

    }




//    @Override
//    public String AiPredictByKeywords(String userRequirement) {
//        System.out.println(keywordArray);
//        if (keywordArray == null || keywordArray.isEmpty()) {
//            return "关键词为空，请先调用 getKeywordsTable()，请注意：本接口运行慢";
//        }
//        KeywordsPromptBuilderImpl promptBuilder = new KeywordsPromptBuilderImpl();
//        String prompt = promptBuilder.buildPrompt(keywordArray, userRequirement);
//
//        try {
//            AIClient8KServiceImpl client = new AIClient8KServiceImpl();
//            String result = client.callAI("你是一个科研助手，擅长热点预测与趋势分析。", prompt);
//            return result;
//        } catch (Exception e) {
//            e.printStackTrace();
//            return "请求失败：" + e.getMessage();
//        }
//
//
//    }
//    @Override
//    public String AiExtractContent(String userRequirement)  {
//
//        String paperContent="近年来，随着 AI 大模型技术的迅猛发展，其强大的文本理解与生成能力正\n" +
//                "在重塑各行业的工作方式，从而学术研究与教学领域也随之迎来新的契机[1]。在\n" +
//                "本科毕业论文的写作和教学指导过程中，参考文献的选择与分析始终是关键一环，\n" +
//                "其数量、质量与格式可作为科学素养与论文质量的重要反映指标[2]。\n" +
//                "然而，传统的文献管理方式主要依赖手工录入与人工判断，不仅耗时费力，\n" +
//                "还容易出错[3]。而传统的参考文献质量评估主要依靠教师主观判断，难以客观、\n" +
//                "全面地评估文献的学术价值与相关性。因此，如何充分利用大量本科毕业论文资\n" +
//                "源，帮助老师改进教学内容，提高教学质量，并为学生提供选题帮助和引用规范\n" +
//                "指导，成为了一个重要问题。\n" +
//                "该系统集成 AI 大模型的 API 服务，能够对参考文献内容进行自动拆解，精\n" +
//                "准提取标题、作者等元数据信息，并进一步实现文献质量评估、文献推荐等功能。\n" +
//                "借助上述功能，辅助学生发现高价值文献、优化选题方向；同时也帮助教师快速\n" +
//                "掌握学生的文献质量情况，改进指导方法。\n" +
//                "当下，数字化转型浪潮正席卷全球，推动教育数字化转型是应对时代变迁的\n" +
//                "战略选择[4]。本系统的开发不仅响应了当前的发展趋势，而且以调用 AI 大模型\n" +
//                "API 为核心优势，对提高教学水平、改进相关课程和推荐研究方向都有一定的实\n" +
//                "际意义和推广价值。\n";
//        ExtractContentPromptBuilderImpl promptBuilder  = new ExtractContentPromptBuilderImpl();
//        String prompt = promptBuilder.buildPrompt(paperContent, userRequirement);
//
//        try {
//            AIClient32KServiceImpl client = new AIClient32KServiceImpl();
//            String result = client.callAI("你是一个擅长总结科研助手，擅长从论文的正文中抽取摘要。", prompt);
//            return result;
//        } catch (Exception e) {
//            e.printStackTrace();
//            return "请求失败：" + e.getMessage();
//        }
//    }


}
